﻿using System;
using System.ComponentModel;
using System.Runtime.InteropServices;

namespace Teigha.Core
{
	public class OdGsEntityNode : OdGsNode, OdSiEntity
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public OdGsEntityNode(IntPtr cPtr, bool cMemoryOwn) : base(GlobalsPINVOKE.OdGsEntityNode_SWIGUpcast(cPtr), cMemoryOwn)
		{
			this.swigCPtr = new HandleRef(this, cPtr);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static HandleRef getCPtr(OdGsEntityNode obj)
		{
			if (obj != null)
			{
				return obj.swigCPtr;
			}
			return new HandleRef(null, IntPtr.Zero);
		}

		~OdGsEntityNode()
		{
			this.Dispose();
		}

		public override void Dispose()
		{
			if (this.swigCPtr.Handle != IntPtr.Zero)
			{
				if (this.swigCMemOwn)
				{
					lock (this.locker)
					{
						if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
						{
							this.swigCMemOwn = false;
							GlobalsPINVOKE.delete_OdGsEntityNode(this.swigCPtr);
						}
					}
					this.swigCMemOwn = false;
				}
				this.swigCPtr = new HandleRef(null, IntPtr.Zero);
			}
			GC.SuppressFinalize(this);
			base.Dispose();
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		HandleRef OdSiEntity.GetCPtr()
		{
			return new HandleRef(this, GlobalsPINVOKE.OdGsEntityNode_OdSiEntity_GetCPtr(this.swigCPtr.Handle));
		}

		public static IntPtr Alloc(uint nBytes)
		{
			IntPtr result = GlobalsPINVOKE.OdGsEntityNode_Alloc(nBytes);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static void Free(IntPtr pMemBlock)
		{
			GlobalsPINVOKE.OdGsEntityNode_Free(pMemBlock);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static IntPtr Realloc(IntPtr pMemBlock, uint newSize, uint arg2)
		{
			IntPtr result = GlobalsPINVOKE.OdGsEntityNode_Realloc(pMemBlock, newSize, arg2);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGsEntityNode.Metafile getEmptyMetafile(uint flags, OdGsLayerNode pLayerNode)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsEntityNode_getEmptyMetafile__SWIG_0(flags, OdGsLayerNode.getCPtr(pLayerNode));
			OdGsEntityNode.Metafile result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsEntityNode.Metafile)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsEntityNode.Metafile)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsEntityNode.Metafile)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGsEntityNode.Metafile getEmptyMetafile(uint flags)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsEntityNode_getEmptyMetafile__SWIG_1(flags);
			OdGsEntityNode.Metafile result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsEntityNode.Metafile)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsEntityNode.Metafile)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsEntityNode.Metafile)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGsEntityNode.Metafile metafileAt(int metafileIndex)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsEntityNode_metafileAt(this.swigCPtr, metafileIndex);
			OdGsEntityNode.Metafile result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsEntityNode.Metafile)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsEntityNode.Metafile)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsEntityNode.Metafile)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setMetafileAt(int metafileIndex, OdGsEntityNode.Metafile pMetafile)
		{
			GlobalsPINVOKE.OdGsEntityNode_setMetafileAt(this.swigCPtr, metafileIndex, OdGsEntityNode.Metafile.getCPtr(pMetafile));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdRxObject findCompatibleCache(OdGsViewImpl keyView, SWIGTYPE_p_OdGsUpdateContext ctx, uint awareMask)
		{
			OdRxObject result = Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsEntityNode_findCompatibleCache__SWIG_0(this.swigCPtr, OdGsViewImpl.getCPtr(keyView), SWIGTYPE_p_OdGsUpdateContext.getCPtr(ctx), awareMask), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdRxObject findCompatibleCache(OdGsViewImpl keyView, SWIGTYPE_p_OdGsUpdateContext ctx)
		{
			OdRxObject result = Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsEntityNode_findCompatibleCache__SWIG_1(this.swigCPtr, OdGsViewImpl.getCPtr(keyView), SWIGTYPE_p_OdGsUpdateContext.getCPtr(ctx)), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdGsEntityNode cast(OdRxObject pObj)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsEntityNode_cast(OdRxObject.getCPtr(pObj));
			OdGsEntityNode result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsEntityNode)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsEntityNode)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsEntityNode)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdRxClass desc()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsEntityNode_desc(), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxClass isA()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsEntityNode_isA(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxObject queryX(OdRxClass protocolClass)
		{
			OdRxObject result = Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsEntityNode_queryX(this.swigCPtr, OdRxClass.getCPtr(protocolClass)), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdGsEntityNode createObject()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsEntityNode_createObject();
			OdGsEntityNode result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsEntityNode)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsEntityNode)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsEntityNode)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGsEntityNode(OdGsBaseModel pModel, OdGiDrawable pUnderlyingDrawable, bool bSetGsNode) : this(GlobalsPINVOKE.new_OdGsEntityNode__SWIG_0(OdGsBaseModel.getCPtr(pModel), OdGiDrawable.getCPtr(pUnderlyingDrawable), bSetGsNode), true)
		{
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGsEntityNode(OdGsBaseModel pModel, OdGiDrawable pUnderlyingDrawable) : this(GlobalsPINVOKE.new_OdGsEntityNode__SWIG_1(OdGsBaseModel.getCPtr(pModel), OdGiDrawable.getCPtr(pUnderlyingDrawable)), true)
		{
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setNextEntity(OdGsEntityNode pNextEntity)
		{
			GlobalsPINVOKE.OdGsEntityNode_setNextEntity(this.swigCPtr, OdGsEntityNode.getCPtr(pNextEntity));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGsEntityNode nextEntity()
		{
			OdGsEntityNode result = (OdGsEntityNode)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsEntityNode_nextEntity__SWIG_0(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual uint awareFlags(uint viewportId)
		{
			uint result = GlobalsPINVOKE.OdGsEntityNode_awareFlags(this.swigCPtr, viewportId);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual ENodeType nodeType()
		{
			ENodeType result = (ENodeType)GlobalsPINVOKE.OdGsEntityNode_nodeType(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool isReference()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_isReference(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool isLight()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_isLight(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void select(OdGsBaseVectorizer view)
		{
			GlobalsPINVOKE.OdGsEntityNode_select(this.swigCPtr, OdGsBaseVectorizer.getCPtr(view));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void invalidate(OdGsContainerNode pParent, OdGsViewImpl pView, uint mask)
		{
			GlobalsPINVOKE.OdGsEntityNode_invalidate(this.swigCPtr, OdGsContainerNode.getCPtr(pParent), OdGsViewImpl.getCPtr(pView), mask);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual bool extents(OdGeExtents3d extents)
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_extents__SWIG_0(this.swigCPtr, OdGeExtents3d.getCPtr(extents));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool spatiallyIndexed()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_spatiallyIndexed(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setSpatiallyIndexed(bool spatiallyIndexed)
		{
			GlobalsPINVOKE.OdGsEntityNode_setSpatiallyIndexed(this.swigCPtr, spatiallyIndexed);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool owned()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_owned(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setOwned(bool owned)
		{
			GlobalsPINVOKE.OdGsEntityNode_setOwned(this.swigCPtr, owned);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool hasExtents()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_hasExtents(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGeExtents3d extents()
		{
			OdGeExtents3d result = new OdGeExtents3d(GlobalsPINVOKE.OdGsEntityNode_extents__SWIG_1(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool isEmpty()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_isEmpty(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool markedToSkip(uint mask)
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_markedToSkip(this.swigCPtr, mask);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void markToSkip(uint mask, bool markToSkip)
		{
			GlobalsPINVOKE.OdGsEntityNode_markToSkip(this.swigCPtr, mask, markToSkip);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void markToSkipAll()
		{
			GlobalsPINVOKE.OdGsEntityNode_markToSkipAll(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static uint markToSkipMask(uint threadIndex)
		{
			uint result = GlobalsPINVOKE.OdGsEntityNode_markToSkipMask(threadIndex);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void destroy()
		{
			GlobalsPINVOKE.OdGsEntityNode_destroy(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool layersChanged(OdGsViewImpl view)
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_layersChanged(this.swigCPtr, OdGsViewImpl.getCPtr(view));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool markedAsNonSelectable()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_markedAsNonSelectable(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void markAsNonSelectable(bool val)
		{
			GlobalsPINVOKE.OdGsEntityNode_markAsNonSelectable(this.swigCPtr, val);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isMarkedSkipSelection()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_isMarkedSkipSelection(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void markSkipSelection(bool val)
		{
			GlobalsPINVOKE.OdGsEntityNode_markSkipSelection(this.swigCPtr, val);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isMarkedErased()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_isMarkedErased(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void markErased(bool val)
		{
			GlobalsPINVOKE.OdGsEntityNode_markErased(this.swigCPtr, val);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isInWorkset()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_isInWorkset(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setInWorkset(bool val)
		{
			GlobalsPINVOKE.OdGsEntityNode_setInWorkset(this.swigCPtr, val);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isRegenOnDraw()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_isRegenOnDraw(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setRegenOnDraw(bool val)
		{
			GlobalsPINVOKE.OdGsEntityNode_setRegenOnDraw(this.swigCPtr, val);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isSingleThreaded()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_isSingleThreaded(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setSingleThreaded(bool val)
		{
			GlobalsPINVOKE.OdGsEntityNode_setSingleThreaded(this.swigCPtr, val);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void highlight(bool bDoIt, bool bWholeBranch)
		{
			GlobalsPINVOKE.OdGsEntityNode_highlight(this.swigCPtr, bDoIt, bWholeBranch);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setHlBranch(OdGsHlBranch pBr)
		{
			GlobalsPINVOKE.OdGsEntityNode_setHlBranch(this.swigCPtr, OdGsHlBranch.getCPtr(pBr));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGsHlBranch hlBranch()
		{
			OdGsHlBranch result = new OdGsHlBranch(GlobalsPINVOKE.OdGsEntityNode_hlBranch__SWIG_0(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void playAsGeometry(OdGsBaseVectorizer view, EMetafilePlayMode eMode)
		{
			GlobalsPINVOKE.OdGsEntityNode_playAsGeometry(this.swigCPtr, OdGsBaseVectorizer.getCPtr(view), (int)eMode);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual bool extents(OdGsView pView, OdGeExtents3d ext)
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_extents__SWIG_2(this.swigCPtr, OdGsView.getCPtr(pView), OdGeExtents3d.getCPtr(ext));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual LineWeight getMaxLineweightUsed()
		{
			LineWeight result = (LineWeight)GlobalsPINVOKE.OdGsEntityNode_getMaxLineweightUsed(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void addLineweight(uint lwd)
		{
			GlobalsPINVOKE.OdGsEntityNode_addLineweight(this.swigCPtr, lwd);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setLineweight(uint lwd)
		{
			GlobalsPINVOKE.OdGsEntityNode_setLineweight(this.swigCPtr, lwd);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public uint getLineweight()
		{
			uint result = GlobalsPINVOKE.OdGsEntityNode_getLineweight(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool entityUnerased()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_entityUnerased(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setEntityUnerased(bool flag)
		{
			GlobalsPINVOKE.OdGsEntityNode_setEntityUnerased(this.swigCPtr, flag);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isInvisible()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_isInvisible(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isDrawableRegenDraw()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_isDrawableRegenDraw(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isExtentsOutOfModelSpace()
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_isExtentsOutOfModelSpace(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setExtentsOutOfModelSpace(bool flag)
		{
			GlobalsPINVOKE.OdGsEntityNode_setExtentsOutOfModelSpace(this.swigCPtr, flag);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void resetInvalidVpFlag()
		{
			GlobalsPINVOKE.OdGsEntityNode_resetInvalidVpFlag(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void makeStock()
		{
			GlobalsPINVOKE.OdGsEntityNode_makeStock(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void releaseStock()
		{
			GlobalsPINVOKE.OdGsEntityNode_releaseStock(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void propagateLayerChangesStock()
		{
			GlobalsPINVOKE.OdGsEntityNode_propagateLayerChangesStock(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual bool saveNodeState(SWIGTYPE_p_OdGsFiler pFiler, OdGsBaseVectorizer pVectorizer)
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_saveNodeState__SWIG_0(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler), OdGsBaseVectorizer.getCPtr(pVectorizer));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual bool saveNodeState(SWIGTYPE_p_OdGsFiler pFiler)
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_saveNodeState__SWIG_1(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual bool loadNodeState(SWIGTYPE_p_OdGsFiler pFiler, OdGsBaseVectorizer pVectorizer)
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_loadNodeState__SWIG_0(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler), OdGsBaseVectorizer.getCPtr(pVectorizer));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual bool loadNodeState(SWIGTYPE_p_OdGsFiler pFiler)
		{
			bool result = GlobalsPINVOKE.OdGsEntityNode_loadNodeState__SWIG_1(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		private object locker = new object();

		private HandleRef swigCPtr;

		public class Metafile : OdRxObject
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public Metafile(IntPtr cPtr, bool cMemoryOwn) : base(GlobalsPINVOKE.OdGsEntityNode_Metafile_SWIGUpcast(cPtr), cMemoryOwn)
			{
				this.swigCPtr = new HandleRef(this, cPtr);
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			public static HandleRef getCPtr(OdGsEntityNode.Metafile obj)
			{
				if (obj != null)
				{
					return obj.swigCPtr;
				}
				return new HandleRef(null, IntPtr.Zero);
			}

			~Metafile()
			{
				this.Dispose();
			}

			public override void Dispose()
			{
				if (this.swigCPtr.Handle != IntPtr.Zero)
				{
					if (this.swigCMemOwn)
					{
						lock (this.locker)
						{
							if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
							{
								this.swigCMemOwn = false;
								GlobalsPINVOKE.delete_OdGsEntityNode_Metafile(this.swigCPtr);
							}
						}
						this.swigCMemOwn = false;
					}
					this.swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
				base.Dispose();
			}

			public bool play(OdGsBaseVectorizer view, EMetafilePlayMode eMode, OdGsEntityNode node, SWIGTYPE_p_OdGsBaseContext ctx)
			{
				bool result = GlobalsPINVOKE.OdGsEntityNode_Metafile_play__SWIG_0(this.swigCPtr, OdGsBaseVectorizer.getCPtr(view), (int)eMode, OdGsEntityNode.getCPtr(node), SWIGTYPE_p_OdGsBaseContext.getCPtr(ctx));
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public bool play(OdGsBaseVectorizer view, EMetafilePlayMode eMode, OdGsEntityNode node)
			{
				bool result = GlobalsPINVOKE.OdGsEntityNode_Metafile_play__SWIG_1(this.swigCPtr, OdGsBaseVectorizer.getCPtr(view), (int)eMode, OdGsEntityNode.getCPtr(node));
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public bool playNested(OdGsView view, OdGsEntityNode node, SWIGTYPE_p_OdGsBaseContext ctx)
			{
				bool result = GlobalsPINVOKE.OdGsEntityNode_Metafile_playNested(this.swigCPtr, OdGsView.getCPtr(view), OdGsEntityNode.getCPtr(node), SWIGTYPE_p_OdGsBaseContext.getCPtr(ctx));
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public bool hasDataToPlay(OdGsBaseVectorizer view, EMetafilePlayMode eMode)
			{
				bool result = GlobalsPINVOKE.OdGsEntityNode_Metafile_hasDataToPlay__SWIG_0(this.swigCPtr, OdGsBaseVectorizer.getCPtr(view), (int)eMode);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public bool hasDataToPlay(OdGsBaseVectorizer view)
			{
				bool result = GlobalsPINVOKE.OdGsEntityNode_Metafile_hasDataToPlay__SWIG_1(this.swigCPtr, OdGsBaseVectorizer.getCPtr(view));
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public bool layersChanged(uint nVpId)
			{
				bool result = GlobalsPINVOKE.OdGsEntityNode_Metafile_layersChanged(this.swigCPtr, nVpId);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public bool containsVpFrozenLayers()
			{
				bool result = GlobalsPINVOKE.OdGsEntityNode_Metafile_containsVpFrozenLayers(this.swigCPtr);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public bool isEmpty()
			{
				bool result = GlobalsPINVOKE.OdGsEntityNode_Metafile_isEmpty(this.swigCPtr);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public uint m_nAwareFlags
			{
				get
				{
					uint result = GlobalsPINVOKE.OdGsEntityNode_Metafile_m_nAwareFlags_get(this.swigCPtr);
					if (GlobalsPINVOKE.SWIGPendingException.Pending)
					{
						throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
					}
					return result;
				}
				set
				{
					GlobalsPINVOKE.OdGsEntityNode_Metafile_m_nAwareFlags_set(this.swigCPtr, value);
					if (GlobalsPINVOKE.SWIGPendingException.Pending)
					{
						throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
					}
				}
			}

			public OdGeExtents3d m_extents
			{
				get
				{
					IntPtr intPtr = GlobalsPINVOKE.OdGsEntityNode_Metafile_m_extents_get(this.swigCPtr);
					OdGeExtents3d result = (intPtr == IntPtr.Zero) ? null : new OdGeExtents3d(intPtr, false);
					if (GlobalsPINVOKE.SWIGPendingException.Pending)
					{
						throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
					}
					return result;
				}
				set
				{
					GlobalsPINVOKE.OdGsEntityNode_Metafile_m_extents_set(this.swigCPtr, OdGeExtents3d.getCPtr(value));
					if (GlobalsPINVOKE.SWIGPendingException.Pending)
					{
						throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
					}
				}
			}

			public OdGsGeomPortion m_first
			{
				get
				{
					IntPtr intPtr = GlobalsPINVOKE.OdGsEntityNode_Metafile_m_first_get(this.swigCPtr);
					OdGsGeomPortion result = (intPtr == IntPtr.Zero) ? null : new OdGsGeomPortion(intPtr, false);
					if (GlobalsPINVOKE.SWIGPendingException.Pending)
					{
						throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
					}
					return result;
				}
				set
				{
					GlobalsPINVOKE.OdGsEntityNode_Metafile_m_first_set(this.swigCPtr, OdGsGeomPortion.getCPtr(value));
					if (GlobalsPINVOKE.SWIGPendingException.Pending)
					{
						throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
					}
				}
			}

			private object locker = new object();

			private HandleRef swigCPtr;
		}

		public class MetafilePtrArray : IDisposable
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public MetafilePtrArray(IntPtr cPtr, bool cMemoryOwn)
			{
				this.swigCMemOwn = cMemoryOwn;
				this.swigCPtr = new HandleRef(this, cPtr);
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			public static HandleRef getCPtr(OdGsEntityNode.MetafilePtrArray obj)
			{
				if (obj != null)
				{
					return obj.swigCPtr;
				}
				return new HandleRef(null, IntPtr.Zero);
			}

			~MetafilePtrArray()
			{
				this.Dispose();
			}

			public virtual void Dispose()
			{
				if (this.swigCPtr.Handle != IntPtr.Zero)
				{
					if (this.swigCMemOwn)
					{
						lock (this.locker)
						{
							if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
							{
								this.swigCMemOwn = false;
								GlobalsPINVOKE.delete_OdGsEntityNode_MetafilePtrArray(this.swigCPtr);
							}
						}
						this.swigCMemOwn = false;
					}
					this.swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}

			public MetafilePtrArray() : this(GlobalsPINVOKE.new_OdGsEntityNode_MetafilePtrArray(), true)
			{
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}

			private object locker = new object();

			private HandleRef swigCPtr;

			protected bool swigCMemOwn;
		}

		public class MetafileHolder : IDisposable
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public MetafileHolder(IntPtr cPtr, bool cMemoryOwn)
			{
				this.swigCMemOwn = cMemoryOwn;
				this.swigCPtr = new HandleRef(this, cPtr);
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			public static HandleRef getCPtr(OdGsEntityNode.MetafileHolder obj)
			{
				if (obj != null)
				{
					return obj.swigCPtr;
				}
				return new HandleRef(null, IntPtr.Zero);
			}

			~MetafileHolder()
			{
				this.Dispose();
			}

			public virtual void Dispose()
			{
				if (this.swigCPtr.Handle != IntPtr.Zero)
				{
					if (this.swigCMemOwn)
					{
						lock (this.locker)
						{
							if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
							{
								this.swigCMemOwn = false;
								GlobalsPINVOKE.delete_OdGsEntityNode_MetafileHolder(this.swigCPtr);
							}
						}
						this.swigCMemOwn = false;
					}
					this.swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}

			public MetafileHolder() : this(GlobalsPINVOKE.new_OdGsEntityNode_MetafileHolder__SWIG_0(), true)
			{
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}

			public MetafileHolder(OdGsEntityNode.MetafileHolder c) : this(GlobalsPINVOKE.new_OdGsEntityNode_MetafileHolder__SWIG_1(OdGsEntityNode.MetafileHolder.getCPtr(c)), true)
			{
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}

			public bool isValid()
			{
				bool result = GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_isValid(this.swigCPtr);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public bool isArray()
			{
				bool result = GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_isArray(this.swigCPtr);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public bool isVpDependent()
			{
				bool result = GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_isVpDependent(this.swigCPtr);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public void setVpDependent(bool bOn)
			{
				GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_setVpDependent(this.swigCPtr, bOn);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}

			public bool isAwareFlagsRegenType()
			{
				bool result = GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_isAwareFlagsRegenType(this.swigCPtr);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public bool isRegenTypeDependent()
			{
				bool result = GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_isRegenTypeDependent(this.swigCPtr);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public void setDependentGeometry(bool bSet)
			{
				GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_setDependentGeometry(this.swigCPtr, bSet);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}

			public bool isDependentGeometry()
			{
				bool result = GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_isDependentGeometry(this.swigCPtr);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public void setLayerDependent(bool bSet)
			{
				GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_setLayerDependent(this.swigCPtr, bSet);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}

			public bool isLayerDependent()
			{
				bool result = GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_isLayerDependent(this.swigCPtr);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public OdGsEntityNode.Metafile get()
			{
				OdGsEntityNode.Metafile result = (OdGsEntityNode.Metafile)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_get__SWIG_0(this.swigCPtr), false);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public OdGsEntityNode.MetafilePtrArray getArray()
			{
				OdGsEntityNode.MetafilePtrArray result = new OdGsEntityNode.MetafilePtrArray(GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_getArray__SWIG_0(this.swigCPtr), false);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public void set(OdGsEntityNode.Metafile pMf)
			{
				GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_set(this.swigCPtr, OdGsEntityNode.Metafile.getCPtr(pMf));
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}

			public void setAtRegenType(OdGsEntityNode.Metafile pMf, OdGiRegenType eRegenType)
			{
				GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_setAtRegenType(this.swigCPtr, OdGsEntityNode.Metafile.getCPtr(pMf), (int)eRegenType);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}

			public OdGsEntityNode.Metafile getAtRegenType(SWIGTYPE_p_OdGiRegenType eRegenType)
			{
				OdGsEntityNode.Metafile result = (OdGsEntityNode.Metafile)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_getAtRegenType(this.swigCPtr, SWIGTYPE_p_OdGiRegenType.getCPtr(eRegenType)), false);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public void allocateArray()
			{
				GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_allocateArray(this.swigCPtr);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}

			public void destroy()
			{
				GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_destroy(this.swigCPtr);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}

			public int checkValid()
			{
				int result = GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_checkValid(this.swigCPtr);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public void moveTo(OdGsEntityNode.MetafileHolder c, out int n)
			{
				GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_moveTo(this.swigCPtr, OdGsEntityNode.MetafileHolder.getCPtr(c), out n);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}

			public uint awareFlags(uint nVpID)
			{
				uint result = GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_awareFlags(this.swigCPtr, nVpID);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}

			public void setAt(int n, OdGsEntityNode.Metafile pMf)
			{
				GlobalsPINVOKE.OdGsEntityNode_MetafileHolder_setAt(this.swigCPtr, n, OdGsEntityNode.Metafile.getCPtr(pMf));
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}

			public const int kArray = 1;

			public const int kVpDependent = 2;

			public const int kAwareFlagsRegenType = 4;

			public const int kRegenTypeStandard = 8;

			public const int kRegenTypeHideOrShade = 16;

			public const int kRegenTypeRenderCommand = 32;

			public const int kRegenTypeMask = 56;

			public const int kDependentGeometry = 64;

			public const int kLayerDependent = 128;

			private object locker = new object();

			private HandleRef swigCPtr;

			protected bool swigCMemOwn;
		}
	}
}
